﻿/**
* CODE ADD 2
* @class Ext.History
* @extends Ext.util.Observable
* History management component that allows you to register arbitrary tokens that signify application
* history state on navigation actions.  You can then handle the history {@link #change} event in order
* to reset your application UI to the appropriate state when the user navigates forward or backward through
* the browser history stack.
* @singleton
*/
/**
* @class Ext.History
* @extends Ext.util.Observable
* History management component that allows you to register arbitrary tokens that signify application
* history state on navigation actions.  You can then handle the history {@link #change} event in order
* to reset your application UI to the appropriate state when the user navigates forward or backward through
* the browser history stack.
* @singleton
*/
Ext.History = (function () {
    var iframe, hiddenField;
    var ready = false;
    var currentToken;

    function getHash() {
     try{
            var href = location.href, i = href.indexOf("#"),
                hash = i >= 0 ? href.substr(i + 1) : null;

            if (Ext.isGecko) {
                hash = decodeURIComponent(hash);
            }
            return hash;
         } catch (e) {
            throw ('Ext.util.history.getHash ' + e.message);
        }
    }

    function doSave() {
        hiddenField.value = currentToken;
    }

    function handleStateChange(token) {
        try{
            currentToken = token;
            Ext.History.fireEvent('change', token);
         } catch (e) {
            throw ('Ext.util.history.handleStateChange ' + e.message);
        }
    }

    function updateIFrame(token) {
        var html = ['<html><body><div id="state">', Ext.util.Format.htmlEncode(token), '</div></body></html>'].join('');
        try {
            var doc = iframe.contentWindow.document;
            doc.open();
            doc.write(html);
            doc.close();
            return true;
        } catch (e) {
            return false;
        }
    }

    function checkIFrame() {
    try{
        if (!iframe.contentWindow || !iframe.contentWindow.document) {
            setTimeout(checkIFrame, 10);
            return;
        }

        var doc = iframe.contentWindow.document;
        var elem = doc.getElementById("state");
        var token = elem ? elem.innerText : null;

        var hash = getHash();

        setInterval(function () {

            doc = iframe.contentWindow.document;
            elem = doc.getElementById("state");

            var newtoken = elem ? elem.innerText : null;

            var newHash = getHash();

            if (newtoken !== token) {
                token = newtoken;
                handleStateChange(token);
                location.hash = token;
                hash = token;
                doSave();
            } else if (newHash !== hash) {
                hash = newHash;
                updateIFrame(newHash);
            }

        }, 50);

        ready = true;

        Ext.History.fireEvent('ready', Ext.History);
        } catch (e) {
            throw ('Ext.util.history.checkIFrame ' + e.message);
        }
    }

    function startUp() {
    try{
            currentToken = hiddenField.value ? hiddenField.value : getHash();

            if (Ext.isIE) {
                checkIFrame();
            } else {
                var hash = getHash();
                setInterval(function () {
                    var newHash = getHash();
                    if (newHash !== hash) {
                        hash = newHash;
                        handleStateChange(hash);
                        doSave();
                    }
                }, 50);
                ready = true;
                Ext.History.fireEvent('ready', Ext.History);
            }
        } catch (e) {
            throw ('Ext.util.history.startUp ' + e.message);
        }
    }

    return {
        /**
        * The id of the hidden field required for storing the current history token.
        * @type String
        * @property
        */
        fieldId: 'x-history-field',
        /**
        * The id of the iframe required by IE to manage the history stack.
        * @type String
        * @property
        */
        iframeId: 'x-history-frame',

        events: {},

        /**
        * Initialize the global History instance.
        * @param {Boolean} onReady (optional) A callback function that will be called once the history
        * component is fully initialized.
        * @param {Object} scope (optional) The scope (<code>this</code> reference) in which the callback is executed. Defaults to the browser window.
        */
        init: function (onReady, scope) {
             try{
                    if (ready) {
                        Ext.callback(onReady, scope, [this]);
                        return;
                    }
                    if (!Ext.isReady) {
                        Ext.onReady(function () {
                            Ext.History.init(onReady, scope);
                        });
                        return;
                    }
                    hiddenField = Ext.getDom(Ext.History.fieldId);
                    if (Ext.isIE) {
                        iframe = Ext.getDom(Ext.History.iframeId);
                    }
                    this.addEvents(
                    /**
                    * @event ready
                    * Fires when the Ext.History singleton has been initialized and is ready for use.
                    * @param {Ext.History} The Ext.History singleton.
                    */
                        'ready',
                    /**
                    * @event change
                    * Fires when navigation back or forwards within the local page's history occurs.
                    * @param {String} token An identifier associated with the page state at that point in its history.
                    */
                        'change'
                    );
                    if (onReady) {
                        this.on('ready', onReady, scope, { single: true });
                    }
                    startUp();
            }
            catch (e) {
                throw ('Ext.util.history.init ' + e.message);
            }
        },

        /**
        * Add a new token to the history stack. This can be any arbitrary value, although it would
        * commonly be the concatenation of a component id and another id marking the specifc history
        * state of that component.  Example usage:
        * <pre><code>
        // Handle tab changes on a TabPanel
        tabPanel.on('tabchange', function(tabPanel, tab){
        Ext.History.add(tabPanel.id + ':' + tab.id);
        });
        </code></pre>
        * @param {String} token The value that defines a particular application-specific history state
        * @param {Boolean} preventDuplicates When true, if the passed token matches the current token
        * it will not save a new history step. Set to false if the same state can be saved more than once
        * at the same history stack location (defaults to true).
        */
        add: function (token, preventDup) {
            try{
                    if (preventDup !== false) {
                        if (this.getToken() == token) {
                            return true;
                        }
                    }
                    if (Ext.isIE) {
                        return updateIFrame(token);
                    } else {
                        location.hash = token;
                        return true;
                    }
             }
            catch (e) {
                throw ('Ext.util.history.init ' + e.message);
            }
        },

        /**
        * Programmatically steps back one step in browser history (equivalent to the user pressing the Back button).
        */
        back: function () {
            history.go(-1);
        },

        /**
        * Programmatically steps forward one step in browser history (equivalent to the user pressing the Forward button).
        */
        forward: function () {
            history.go(1);
        },

        /**
        * Retrieves the currently-active history token.
        * @return {String} The token
        */
        getToken: function () {
            return ready ? currentToken : getHash();
        }
    };
})();

Ext.apply(Ext.History, new Ext.util.Observable());